home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / mx / managers / ToolTipManagerImpl.as < prev   
Encoding:
Text File  |  2010-05-14  |  19.9 KB  |  671 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.EventDispatcher;
  6.    import flash.events.MouseEvent;
  7.    import flash.events.TimerEvent;
  8.    import flash.geom.Point;
  9.    import flash.geom.Rectangle;
  10.    import flash.utils.Timer;
  11.    import mx.controls.ToolTip;
  12.    import mx.core.Application;
  13.    import mx.core.IInvalidating;
  14.    import mx.core.IToolTip;
  15.    import mx.core.IUIComponent;
  16.    import mx.core.mx_internal;
  17.    import mx.effects.Effect;
  18.    import mx.effects.EffectManager;
  19.    import mx.events.EffectEvent;
  20.    import mx.events.ToolTipEvent;
  21.    import mx.styles.IStyleClient;
  22.    import mx.validators.IValidatorListener;
  23.    
  24.    use namespace mx_internal;
  25.    
  26.    public class ToolTipManagerImpl extends EventDispatcher implements IToolTipManager
  27.    {
  28.       private static var instance:IToolTipManager;
  29.       
  30.       mx_internal static const VERSION:String = "2.0.1.0";
  31.       
  32.       private var _enabled:Boolean = true;
  33.       
  34.       private var _showDelay:Number = 500;
  35.       
  36.       private var _hideEffect:Effect;
  37.       
  38.       private var hideTimer:Timer;
  39.       
  40.       private var _toolTipClass:Class;
  41.       
  42.       private var _scrubDelay:Number = 100;
  43.       
  44.       private var showTimer:Timer;
  45.       
  46.       private var _currentToolTip:IToolTip;
  47.       
  48.       private var currentText:String;
  49.       
  50.       private var scrubTimer:Timer;
  51.       
  52.       private var previousTarget:DisplayObject;
  53.       
  54.       private var _currentTarget:DisplayObject;
  55.       
  56.       private var _showEffect:Effect;
  57.       
  58.       private var initialized:Boolean = false;
  59.       
  60.       private var _hideDelay:Number = 10000;
  61.       
  62.       private var isError:Boolean;
  63.       
  64.       public function ToolTipManagerImpl()
  65.       {
  66.          initialized = false;
  67.          _enabled = true;
  68.          _hideDelay = 10000;
  69.          _scrubDelay = 100;
  70.          _showDelay = 500;
  71.          _toolTipClass = ToolTip;
  72.          super();
  73.          if(instance)
  74.          {
  75.             throw new Error("Instance already exists.");
  76.          }
  77.       }
  78.       
  79.       public static function getInstance() : IToolTipManager
  80.       {
  81.          if(!instance)
  82.          {
  83.             instance = new ToolTipManagerImpl();
  84.          }
  85.          return instance;
  86.       }
  87.       
  88.       private function toolTipMouseOverHandler(param1:MouseEvent) : void
  89.       {
  90.          checkIfTargetChanged(DisplayObject(param1.target));
  91.       }
  92.       
  93.       private function showTimer_timerHandler(param1:TimerEvent) : void
  94.       {
  95.          if(currentTarget)
  96.          {
  97.             createTip();
  98.             initializeTip();
  99.             positionTip();
  100.             showTip();
  101.          }
  102.       }
  103.       
  104.       private function systemManager_mouseDownHandler(param1:MouseEvent) : void
  105.       {
  106.          reset();
  107.       }
  108.       
  109.       public function set showDelay(param1:Number) : void
  110.       {
  111.          _showDelay = param1;
  112.       }
  113.       
  114.       private function hideEffectEnded() : void
  115.       {
  116.          var _loc1_:ToolTipEvent = null;
  117.          reset();
  118.          if(previousTarget)
  119.          {
  120.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_END);
  121.             _loc1_.toolTip = currentToolTip;
  122.             previousTarget.dispatchEvent(_loc1_);
  123.          }
  124.       }
  125.       
  126.       public function set scrubDelay(param1:Number) : void
  127.       {
  128.          _scrubDelay = param1;
  129.       }
  130.       
  131.       public function get currentToolTip() : IToolTip
  132.       {
  133.          return _currentToolTip;
  134.       }
  135.       
  136.       private function toolTipMouseOutHandler(param1:MouseEvent) : void
  137.       {
  138.          checkIfTargetChanged(param1.relatedObject);
  139.       }
  140.       
  141.       public function get enabled() : Boolean
  142.       {
  143.          return _enabled;
  144.       }
  145.       
  146.       public function createToolTip(param1:String, param2:Number, param3:Number, param4:String = null, param5:IUIComponent = null) : IToolTip
  147.       {
  148.          var _loc6_:ToolTip = null;
  149.          var _loc7_:ISystemManager = null;
  150.          _loc6_ = new ToolTip();
  151.          _loc7_ = !!param5 ? param5.systemManager : Application.application.systemManager;
  152.          _loc7_.toolTipChildren.addChild(_loc6_);
  153.          if(param4)
  154.          {
  155.             _loc6_.setStyle("styleName","errorTip");
  156.             _loc6_.setStyle("borderStyle",param4);
  157.          }
  158.          _loc6_.text = param1;
  159.          sizeTip(_loc6_);
  160.          _loc6_.move(param2,param3);
  161.          return _loc6_ as IToolTip;
  162.       }
  163.       
  164.       private function reset() : void
  165.       {
  166.          var _loc1_:ISystemManager = null;
  167.          showTimer.reset();
  168.          hideTimer.reset();
  169.          if(currentToolTip)
  170.          {
  171.             if(Boolean(showEffect) || Boolean(hideEffect))
  172.             {
  173.                currentToolTip.removeEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  174.             }
  175.             EffectManager.endEffectsForTarget(currentToolTip);
  176.             _loc1_ = getSystemManager(previousTarget);
  177.             _loc1_.toolTipChildren.removeChild(DisplayObject(currentToolTip));
  178.             currentToolTip = null;
  179.             scrubTimer.delay = scrubDelay;
  180.             scrubTimer.reset();
  181.             if(scrubDelay > 0)
  182.             {
  183.                scrubTimer.delay = scrubDelay;
  184.                scrubTimer.start();
  185.             }
  186.          }
  187.       }
  188.       
  189.       public function set currentToolTip(param1:IToolTip) : void
  190.       {
  191.          _currentToolTip = param1;
  192.       }
  193.       
  194.       private function showTip() : void
  195.       {
  196.          var _loc1_:ToolTipEvent = null;
  197.          var _loc2_:ISystemManager = null;
  198.          _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOW);
  199.          _loc1_.toolTip = currentToolTip;
  200.          currentTarget.dispatchEvent(_loc1_);
  201.          if(isError)
  202.          {
  203.             currentTarget.addEventListener("change",changeHandler);
  204.          }
  205.          else
  206.          {
  207.             _loc2_ = getSystemManager(currentTarget);
  208.             _loc2_.addEventListener(MouseEvent.MOUSE_DOWN,systemManager_mouseDownHandler);
  209.          }
  210.          currentToolTip.visible = true;
  211.          if(!showEffect)
  212.          {
  213.             showEffectEnded();
  214.          }
  215.       }
  216.       
  217.       private function effectEndHandler(param1:EffectEvent) : void
  218.       {
  219.          if(param1.effectInstance.effect == showEffect)
  220.          {
  221.             showEffectEnded();
  222.          }
  223.          else if(param1.effectInstance.effect == hideEffect)
  224.          {
  225.             hideEffectEnded();
  226.          }
  227.       }
  228.       
  229.       public function get hideDelay() : Number
  230.       {
  231.          return _hideDelay;
  232.       }
  233.       
  234.       public function get toolTipClass() : Class
  235.       {
  236.          return _toolTipClass;
  237.       }
  238.       
  239.       public function get currentTarget() : DisplayObject
  240.       {
  241.          return _currentTarget;
  242.       }
  243.       
  244.       public function get hideEffect() : Effect
  245.       {
  246.          return _hideEffect;
  247.       }
  248.       
  249.       private function showEffectEnded() : void
  250.       {
  251.          var _loc1_:ToolTipEvent = null;
  252.          if(hideDelay == 0)
  253.          {
  254.             hideTip();
  255.          }
  256.          else if(hideDelay < Infinity)
  257.          {
  258.             hideTimer.delay = hideDelay;
  259.             hideTimer.start();
  260.          }
  261.          if(currentTarget)
  262.          {
  263.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOWN);
  264.             _loc1_.toolTip = currentToolTip;
  265.             currentTarget.dispatchEvent(_loc1_);
  266.          }
  267.       }
  268.       
  269.       public function set enabled(param1:Boolean) : void
  270.       {
  271.          _enabled = param1;
  272.       }
  273.       
  274.       private function errorTipMouseOverHandler(param1:MouseEvent) : void
  275.       {
  276.          checkIfTargetChanged(DisplayObject(param1.target));
  277.       }
  278.       
  279.       public function get scrubDelay() : Number
  280.       {
  281.          return _scrubDelay;
  282.       }
  283.       
  284.       public function get showDelay() : Number
  285.       {
  286.          return _showDelay;
  287.       }
  288.       
  289.       public function registerErrorString(param1:DisplayObject, param2:String) : void
  290.       {
  291.          var _loc3_:String = null;
  292.          _loc3_ = IValidatorListener(param1).errorString;
  293.          if(!_loc3_ && Boolean(param2))
  294.          {
  295.             param1.addEventListener(MouseEvent.MOUSE_OVER,errorTipMouseOverHandler);
  296.             param1.addEventListener(MouseEvent.MOUSE_OUT,errorTipMouseOutHandler);
  297.          }
  298.          else if(Boolean(_loc3_) && !param2)
  299.          {
  300.             param1.removeEventListener(MouseEvent.MOUSE_OVER,errorTipMouseOverHandler);
  301.             param1.removeEventListener(MouseEvent.MOUSE_OUT,errorTipMouseOutHandler);
  302.          }
  303.       }
  304.       
  305.       private function initialize() : void
  306.       {
  307.          if(!showTimer)
  308.          {
  309.             showTimer = new Timer(0,1);
  310.             showTimer.addEventListener(TimerEvent.TIMER,showTimer_timerHandler);
  311.          }
  312.          if(!hideTimer)
  313.          {
  314.             hideTimer = new Timer(0,1);
  315.             hideTimer.addEventListener(TimerEvent.TIMER,hideTimer_timerHandler);
  316.          }
  317.          if(!scrubTimer)
  318.          {
  319.             scrubTimer = new Timer(0,1);
  320.          }
  321.          initialized = true;
  322.       }
  323.       
  324.       public function destroyToolTip(param1:IToolTip) : void
  325.       {
  326.          var _loc2_:ISystemManager = null;
  327.          _loc2_ = param1.systemManager;
  328.          _loc2_.toolTipChildren.removeChild(DisplayObject(param1));
  329.       }
  330.       
  331.       private function checkIfTargetChanged(param1:DisplayObject) : void
  332.       {
  333.          if(!enabled)
  334.          {
  335.             return;
  336.          }
  337.          findTarget(param1);
  338.          if(currentTarget != previousTarget)
  339.          {
  340.             targetChanged();
  341.             previousTarget = currentTarget;
  342.          }
  343.       }
  344.       
  345.       private function changeHandler(param1:Event) : void
  346.       {
  347.          reset();
  348.       }
  349.       
  350.       public function set toolTipClass(param1:Class) : void
  351.       {
  352.          _toolTipClass = param1;
  353.       }
  354.       
  355.       private function getGlobalBounds(param1:DisplayObject) : Rectangle
  356.       {
  357.          var _loc2_:Point = null;
  358.          _loc2_ = new Point(0,0);
  359.          _loc2_ = param1.localToGlobal(_loc2_);
  360.          return new Rectangle(_loc2_.x,_loc2_.y,param1.width,param1.height);
  361.       }
  362.       
  363.       private function positionTip() : void
  364.       {
  365.          var _loc1_:Number = NaN;
  366.          var _loc2_:Number = NaN;
  367.          var _loc3_:Number = NaN;
  368.          var _loc4_:Number = NaN;
  369.          var _loc5_:Rectangle = null;
  370.          var _loc6_:Point = null;
  371.          var _loc7_:IToolTip = null;
  372.          var _loc8_:Number = NaN;
  373.          var _loc9_:Number = NaN;
  374.          var _loc10_:Number = NaN;
  375.          var _loc11_:Number = NaN;
  376.          _loc3_ = currentToolTip.screen.width;
  377.          _loc4_ = currentToolTip.screen.height;
  378.          if(isError)
  379.          {
  380.             _loc5_ = getGlobalBounds(currentTarget);
  381.             _loc1_ = _loc5_.right + 4;
  382.             _loc2_ = _loc5_.top - 1;
  383.             if(_loc1_ + currentToolTip.width > _loc3_)
  384.             {
  385.                _loc8_ = NaN;
  386.                _loc9_ = NaN;
  387.                _loc1_ = _loc5_.left - 2;
  388.                if(_loc1_ + currentToolTip.width + 4 > _loc3_)
  389.                {
  390.                   _loc8_ = _loc3_ - _loc1_ - 4;
  391.                   _loc9_ = Number(Object(toolTipClass).maxWidth);
  392.                   Object(toolTipClass).maxWidth = _loc8_;
  393.                   if(currentToolTip is IStyleClient)
  394.                   {
  395.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  396.                   }
  397.                   currentToolTip["text"] = currentToolTip["text"];
  398.                   Object(toolTipClass).maxWidth = _loc9_;
  399.                }
  400.                else
  401.                {
  402.                   if(currentToolTip is IStyleClient)
  403.                   {
  404.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  405.                   }
  406.                   currentToolTip["text"] = currentToolTip["text"];
  407.                }
  408.                if(currentToolTip.height + 2 < _loc5_.top)
  409.                {
  410.                   _loc2_ = _loc5_.top - (currentToolTip.height + 2);
  411.                }
  412.                else
  413.                {
  414.                   _loc2_ = _loc5_.bottom + 2;
  415.                   if(!isNaN(_loc8_))
  416.                   {
  417.                      Object(toolTipClass).maxWidth = _loc8_;
  418.                   }
  419.                   if(currentToolTip is IStyleClient)
  420.                   {
  421.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipBelow");
  422.                   }
  423.                   currentToolTip["text"] = currentToolTip["text"];
  424.                   if(!isNaN(_loc9_))
  425.                   {
  426.                      Object(toolTipClass).maxWidth = _loc9_;
  427.                   }
  428.                }
  429.             }
  430.             sizeTip(currentToolTip);
  431.             _loc6_ = new Point(_loc1_,_loc2_);
  432.             _loc7_ = currentToolTip;
  433.             _loc6_ = DisplayObject(_loc7_).root.globalToLocal(_loc6_);
  434.             _loc1_ = _loc6_.x;
  435.             _loc2_ = _loc6_.y;
  436.          }
  437.          else
  438.          {
  439.             _loc1_ = Application.application.mouseX + 11;
  440.             _loc2_ = Application.application.mouseY + 22;
  441.             _loc10_ = Number(currentToolTip.width);
  442.             if(_loc1_ + _loc10_ > _loc3_)
  443.             {
  444.                _loc1_ = _loc3_ - _loc10_;
  445.             }
  446.             _loc11_ = Number(currentToolTip.height);
  447.             if(_loc2_ + _loc11_ > _loc4_)
  448.             {
  449.                _loc2_ = _loc4_ - _loc11_;
  450.             }
  451.          }
  452.          currentToolTip.move(_loc1_,_loc2_);
  453.       }
  454.       
  455.       private function errorTipMouseOutHandler(param1:MouseEvent) : void
  456.       {
  457.          checkIfTargetChanged(param1.relatedObject);
  458.       }
  459.       
  460.       private function findTarget(param1:DisplayObject) : void
  461.       {
  462.          while(param1)
  463.          {
  464.             if(param1 is IValidatorListener)
  465.             {
  466.                currentText = IValidatorListener(param1).errorString;
  467.                if(currentText != null && currentText != "")
  468.                {
  469.                   currentTarget = param1;
  470.                   isError = true;
  471.                   return;
  472.                }
  473.             }
  474.             if(param1 is IToolTipManagerClient)
  475.             {
  476.                currentText = IToolTipManagerClient(param1).toolTip;
  477.                if(currentText != null)
  478.                {
  479.                   currentTarget = param1;
  480.                   isError = false;
  481.                   return;
  482.                }
  483.             }
  484.             param1 = param1.parent;
  485.          }
  486.          currentText = null;
  487.          currentTarget = null;
  488.       }
  489.       
  490.       public function registerToolTip(param1:DisplayObject, param2:String) : void
  491.       {
  492.          var _loc3_:String = null;
  493.          if(param1 is IToolTipManagerClient)
  494.          {
  495.             _loc3_ = IToolTipManagerClient(param1).toolTip;
  496.          }
  497.          if(!_loc3_ && Boolean(param2))
  498.          {
  499.             param1.addEventListener(MouseEvent.MOUSE_OVER,toolTipMouseOverHandler);
  500.             param1.addEventListener(MouseEvent.MOUSE_OUT,toolTipMouseOutHandler);
  501.          }
  502.          else if(Boolean(_loc3_) && !param2)
  503.          {
  504.             param1.removeEventListener(MouseEvent.MOUSE_OVER,toolTipMouseOverHandler);
  505.             param1.removeEventListener(MouseEvent.MOUSE_OUT,toolTipMouseOutHandler);
  506.          }
  507.       }
  508.       
  509.       public function set hideDelay(param1:Number) : void
  510.       {
  511.          _hideDelay = param1;
  512.       }
  513.       
  514.       private function getSystemManager(param1:DisplayObject) : ISystemManager
  515.       {
  516.          return param1 is IUIComponent ? IUIComponent(param1).systemManager : null;
  517.       }
  518.       
  519.       public function set currentTarget(param1:DisplayObject) : void
  520.       {
  521.          _currentTarget = param1;
  522.       }
  523.       
  524.       public function set showEffect(param1:Effect) : void
  525.       {
  526.          _showEffect = param1;
  527.       }
  528.       
  529.       public function sizeTip(param1:IToolTip) : void
  530.       {
  531.          if(param1 is IInvalidating)
  532.          {
  533.             IInvalidating(param1).validateNow();
  534.          }
  535.          param1.setActualSize(param1.getExplicitOrMeasuredWidth(),param1.getExplicitOrMeasuredHeight());
  536.       }
  537.       
  538.       public function set hideEffect(param1:Effect) : void
  539.       {
  540.          _hideEffect = param1;
  541.       }
  542.       
  543.       private function hideTimer_timerHandler(param1:TimerEvent) : void
  544.       {
  545.          hideTip();
  546.       }
  547.       
  548.       private function targetChanged() : void
  549.       {
  550.          var _loc1_:ToolTipEvent = null;
  551.          if(!initialized)
  552.          {
  553.             initialize();
  554.          }
  555.          if(Boolean(previousTarget) && Boolean(currentToolTip))
  556.          {
  557.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  558.             _loc1_.toolTip = currentToolTip;
  559.             previousTarget.dispatchEvent(_loc1_);
  560.          }
  561.          reset();
  562.          if(currentTarget)
  563.          {
  564.             if(currentText == "")
  565.             {
  566.                return;
  567.             }
  568.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_START);
  569.             currentTarget.dispatchEvent(_loc1_);
  570.             if(showDelay == 0 || scrubTimer.running)
  571.             {
  572.                createTip();
  573.                initializeTip();
  574.                positionTip();
  575.                showTip();
  576.             }
  577.             else
  578.             {
  579.                showTimer.delay = showDelay;
  580.                showTimer.start();
  581.             }
  582.          }
  583.       }
  584.       
  585.       private function initializeTip() : void
  586.       {
  587.          if(currentToolTip is ToolTip)
  588.          {
  589.             ToolTip(currentToolTip).text = currentText;
  590.          }
  591.          if(isError && currentToolTip is IStyleClient)
  592.          {
  593.             IStyleClient(currentToolTip).setStyle("styleName","errorTip");
  594.          }
  595.          sizeTip(currentToolTip);
  596.          if(currentToolTip is IStyleClient)
  597.          {
  598.             if(showEffect)
  599.             {
  600.                IStyleClient(currentToolTip).setStyle("showEffect",showEffect);
  601.             }
  602.             if(hideEffect)
  603.             {
  604.                IStyleClient(currentToolTip).setStyle("hideEffect",hideEffect);
  605.             }
  606.          }
  607.          if(Boolean(showEffect) || Boolean(hideEffect))
  608.          {
  609.             currentToolTip.addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  610.          }
  611.       }
  612.       
  613.       public function get showEffect() : Effect
  614.       {
  615.          return _showEffect;
  616.       }
  617.       
  618.       private function hideTip() : void
  619.       {
  620.          var _loc1_:ToolTipEvent = null;
  621.          var _loc2_:ISystemManager = null;
  622.          if(previousTarget)
  623.          {
  624.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  625.             _loc1_.toolTip = currentToolTip;
  626.             previousTarget.dispatchEvent(_loc1_);
  627.          }
  628.          if(currentToolTip)
  629.          {
  630.             currentToolTip.visible = false;
  631.          }
  632.          if(isError)
  633.          {
  634.             if(currentTarget)
  635.             {
  636.                currentTarget.removeEventListener("change",changeHandler);
  637.             }
  638.          }
  639.          else if(previousTarget)
  640.          {
  641.             _loc2_ = getSystemManager(previousTarget);
  642.             _loc2_.removeEventListener(MouseEvent.MOUSE_DOWN,systemManager_mouseDownHandler);
  643.          }
  644.          if(!hideEffect)
  645.          {
  646.             hideEffectEnded();
  647.          }
  648.       }
  649.       
  650.       private function createTip() : void
  651.       {
  652.          var _loc1_:ToolTipEvent = null;
  653.          var _loc2_:ISystemManager = null;
  654.          _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_CREATE);
  655.          currentTarget.dispatchEvent(_loc1_);
  656.          if(_loc1_.toolTip)
  657.          {
  658.             currentToolTip = _loc1_.toolTip;
  659.          }
  660.          else
  661.          {
  662.             currentToolTip = new toolTipClass();
  663.          }
  664.          currentToolTip.visible = false;
  665.          _loc2_ = getSystemManager(currentTarget);
  666.          _loc2_.toolTipChildren.addChild(DisplayObject(currentToolTip));
  667.       }
  668.    }
  669. }
  670.  
  671.